home *** CD-ROM | disk | FTP | other *** search
/ Light ROM 1 / LIGHT-ROM 1 (Amiga Library Services)(1994).iso / ffdisks / d882.lha / GALer / GALer_english / Source / GALerSrcE.lha / Port.asm < prev    next >
Assembly Source File  |  1992-12-26  |  18KB  |  748 lines
  1.  
  2. *
  3. * Routinen zur Steuerung des GAL-Brenners
  4. *
  5. * assemblieren: as -n -c -d port.asm
  6. *
  7.  
  8.  
  9.  
  10. GAL16V8        EQU    1        ; GAL-Typ
  11. GAL20V8        EQU    2
  12.  
  13. IC1        EQU    3        ; IC-Nummer
  14. IC3        EQU    0
  15. IC4        EQU    1
  16. IC5        EQU    2
  17. IC6        EQU    0
  18. IC7        EQU    1
  19.  
  20. ON        EQU    1        ; für LED-Steuerung
  21. OFF        EQU    0
  22.  
  23. PROG        EQU    1        ; Edit-Mode für GAL
  24. VERIFY        EQU    0
  25.  
  26.  
  27.  
  28. ciaaprb        EQU    $BFE101
  29. ciaaddrb    EQU    $BFE301
  30. ciabpra        EQU    $BFD000
  31. ciabddra    EQU    $BFD200
  32.  
  33.  
  34.     public    _InitParPort        ; Parallel-Port initialisieren
  35.     public    _RestoreParPort        ; Parallel-Port restaurieren
  36.     public    _InitGALer        ; GALer initialisieren
  37.     public    _WriteByte        ; Byte in Schiebereg. schreiben
  38.     public    _ReadByte        ; Byte aus Schiebereg. lesen
  39.     public    _SetGAL            ; GAL-Type festlegen
  40.     public    _VeditOn        ; Edit-Spannung aufbauen
  41.     public    _VeditOff        ; Edit-Spannung abschalten
  42.     public    _LED            ; LED ansteuern
  43.     public    _EnableVcc        ; Vcc anlegen
  44.     public    _DisableVcc        ; Vcc abschalten
  45.     public    _EnableVEdit        ; Edit-Spannung anlegen
  46.     public    _DisableVEdit        ; Edit-Spannung abschalten
  47.     public    _EnableOutput        ; Ausgangs-Treiber aktivieren
  48.     public    _DisableOutput        ; Ausgangs-Treiber deaktiviern
  49.     public    _SetRow            ; Adresse an RAG0-RAG5 anlegen
  50.     public    _SDIn            ; Lege ein Bit an SDIn-Eingang
  51.     public    _SDOut            ; Bit vom SDOut-Ausgang holen
  52.     public    _Clock            ; Clock-Impuls an SCLK-Eingang
  53.     public    _STRImpuls        ; STR-Impuls erzeugen
  54.     public    _EditMode        ; setzt Bits für Edit-Mode
  55.     public    _ExitEditMode        ; Edit-Mode verlassen und Vcc weg
  56.     public    _SetPV            ; VERIFY oder PROG
  57.     public    _SetVolt        ; Edit-Spannung einstellen
  58.  
  59.  
  60.     XDEF    _GALType
  61.     XDEF    _outIC1
  62.     XDEF    _outIC3
  63.     XDEF    _outIC4
  64.     XDEF    _outIC5
  65.  
  66.     XREF    _WaitForTimer
  67.  
  68.     XREF    _LVOForbid
  69.     XREF    _LVOPermit
  70.  
  71.     XREF    _prog_volt
  72.  
  73.     cseg
  74.  
  75.  
  76.  
  77. * initialisiere den Parallel-Port
  78. _InitParPort:
  79.     move.b    ciaaddrb,cia_addrb        ; Datenrichtung der CIAs
  80.     move.b    ciabddra,cia_bddra        ; merken
  81.  
  82.     move.b    #%11111111,ciaaddrb    ; Datenleitungen auf Ausgang schalten
  83.     and.b    #%11111110,ciabddra    ; BUSY auf Eingang
  84.     rts
  85.  
  86.  
  87. * Parallel-Port restaurieren
  88. _RestoreParPort:
  89.     move.b    cia_addrb,ciaaddrb    ; Datenrichtungen der CIAs restau-
  90.                     ; rieren. Der Zustand der Ausgänge
  91.     move.b    cia_bddra,d0        ; wird nicht wieder hergestellt, da
  92.     and.b    #%11111110,ciabddra    ; sonst der angeschlossene GAL-Brenner
  93.     and.b    #%00000001,d0        ; ein unerwünchstes Signal empfangen
  94.     or.b    d0,ciabddra        ; könnte (z.B. Vcc oder VEdit anlegen)
  95.     rts
  96.  
  97.  
  98.  
  99. * GALer initialisieren: alle Ausgänge von IC1 auf LOW (kein OutputEnable
  100. * für IC3,4,5 aber Register-Inhalt von IC3,4,5 auf LOW stellen)
  101. * Parameter: keine
  102. _InitGALer:
  103.     or.b    #%00001000,ciaaprb    ; PD3=H: Adressdecoder deaktivieren!
  104.     and.b    #%00001000,ciaaprb    ; alle anderen Datenleitungen auf LOW
  105.             ; ACHTUNG!!!: PD3 darf nur auf LOW-Pegel gehen
  106.             ; (Adressdecoder aktiviert werden), wenn durch PD0 und
  107.             ; PD1 das IC, das angesprochen werden soll, bereits
  108.             ; selektiert ist. Ansonsten bekommt ein IC einen Takt-
  109.             ; impuls und beim nächsten Strobe liegen dann die
  110.             ; falschen Daten an.
  111.     move.w    #IC1,-(sp)
  112.     clr.w    -(sp)
  113.     bsr    _WriteByte        ; Ausgänge von IC1 auf LOW    
  114.     addq.l    #4,sp            ; Stack korrigieren
  115.     move.w    #IC3,-(sp)
  116.     clr.w    -(sp)
  117.     bsr    _WriteByte        ; Ausgänge von IC3 auf LOW    
  118.     addq.l    #4,sp            ; Stack korrigieren
  119.     move.w    #IC4,-(sp)
  120.     clr.w    -(sp)
  121.     bsr    _WriteByte        ; Ausgänge von IC4 auf LOW    
  122.     addq.l    #4,sp            ; Stack korrigieren
  123.     move.w    #IC5,-(sp)
  124.     clr.w    -(sp)
  125.     bsr    _WriteByte        ; Ausgänge von IC5 auf LOW    
  126.     addq.l    #4,sp            ; Stack korrigieren
  127.     rts
  128.  
  129.  
  130.  
  131. * SetGAL:
  132. * Setzte GAL-Type fest (GAL16V8, GAL20V8)
  133. * Aufruf: SetGAL(type);
  134. *
  135. _SetGAL:
  136.     move.w    4(sp),_GALType
  137.     rts
  138.  
  139.  
  140.  
  141. * VeditOn:
  142. * schaltet den Sperrwandler an (IC9); siehe auch VeditOff
  143. * Auruf: VeditOn();
  144. _VeditOn:
  145.     move.w    #IC1,-(sp)
  146.     or.w    #%00001,_outIC1        ; Q1 von IC1 auf HIGH => VeditOn
  147.     move.w    _outIC1,-(sp)
  148.     bsr    _WriteByte        ; IC1 setzen
  149.     addq.l    #4,sp            ; Stack korrigieren
  150.     rts
  151.  
  152. * VeditOff:
  153. * schaltet den Sperrwandler aus (IC9); siehe auch VeditOn
  154. * Auruf: VeditOff();
  155. _VeditOff:
  156.     move.w    #IC1,-(sp)
  157.     and.w    #%11111110,_outIC1    ; Q1 von IC1 auf LOW => VeditOff
  158.     move.w    _outIC1,-(sp)
  159.     bsr    _WriteByte        ; IC1 setzen
  160.     addq.l    #4,sp            ; Stack korrigieren
  161.     rts
  162.  
  163.  
  164. * EnableVEdit:
  165. * schaltet die Edit-Spannung (+16.5V) auf Pin 2 oder Pin 4 vom Textool
  166. * (abhänging vom eingestellten GAL-Typ)
  167. * Aufruf: EnableVEdit();
  168. _EnableVEdit:
  169.     move.w    #IC1,-(sp)        ; IC1 einstellen
  170.     cmp.w    #GAL16V8,_GALType    ; 16V8 eingestellt?
  171.     bne.s    1$            ; nein, dann wird 20V8 angenommen!
  172.     moveq    #%00000100,d0        ; Q3 von IC1 auf HIGH
  173.     bra.s    2$
  174. 1$    moveq    #%00000010,d0        ; Q2 von IC1 auf HIGH
  175. 2$    or.w    d0,_outIC1
  176.     move.w    _outIC1,-(sp)
  177.     bsr    _WriteByte
  178.     addq.l    #4,sp
  179.     rts
  180.  
  181.  
  182. * DisableVEdit:
  183. * schaltet die Edit-Spannung (+16.5V) an Pin 2 oder Pin 4 aus
  184. * (abhänging vom eingestellten GAL-Typ)
  185. * Aufruf: DisableVEdit();
  186. _DisableVEdit:
  187.     move.w    #IC1,-(sp)        ; IC1 einstellen
  188.     cmp.w    #GAL16V8,_GALType    ; 16V8 eingestellt?
  189.     bne.s    1$            ; nein, dann wird 20V8 angenommen!
  190.     move.w    #%11111011,d0        ; Q3 von IC1 auf LOW
  191.     bra.s    2$
  192. 1$    move.w    #%11111101,d0        ; Q2 von IC1 auf low
  193. 2$    and.w    d0,_outIC1
  194.     move.w    _outIC1,-(sp)
  195.     bsr    _WriteByte
  196.     addq.l    #4,sp
  197.     rts
  198.  
  199.  
  200.  
  201.  
  202. * LED:
  203. * schaltet die LED aus bzw. an
  204. * Aufruf: LED(ON/OFF);
  205. _LED:
  206.     cmp.w    #ON,4(sp)
  207.     bne.s    2$
  208.     or.w    #%01000000,_outIC1
  209.     bra.s    1$
  210. 2$    and.w    #%10111111,_outIC1
  211. 1$    move.w    #IC1,-(sp)
  212.     move.w    _outIC1,-(sp)
  213.     bsr    _WriteByte        ; IC1 setzen
  214.     addq.l    #4,sp            ; Stack korrigieren
  215.     rts
  216.  
  217.  
  218.  
  219. * EnableVcc:
  220. * schaltet die Spannungsversorgung ein; siehe auch DisableVcc
  221. * bei GAL16V8: Pin22 vom Textool-Sockel
  222. * bei GAL20V8: Pin24 vom Textool-Sockel
  223. * Aufruf: EnableVcc();
  224. _EnableVcc:
  225.     movem.l    d0-d7/a0-a6,savereg    ; Register retten
  226.     move.l    #300000,-(sp)        ; 300 ms warten
  227.     jsr    _WaitForTimer        ; 
  228.     addq.l    #4,sp
  229.     movem.l    savereg,d0-d7/a0-a6
  230.  
  231.     move.w    #IC1,-(sp)        ; IC1 selektieren
  232.     cmp.w    #GAL16V8,_GALType    ; 16V8 eingestellt?
  233.     bne.s    1$            ; nein, dann wird 20V8 angenommen!!!
  234.     moveq    #%00011000,d0        ; Q4,5 von IC1 auf HIGH=>+5V an Pin22
  235.     bra.s    2$
  236. 1$    moveq    #%00010000,d0        ; Q5 auf HIGH => +5V an Pin 24    
  237. 2$    or.w    d0,_outIC1
  238.     move.w    _outIC1,-(sp)
  239.     bsr    _WriteByte        ; IC1 setzen
  240.     addq.l    #4,sp            ; Stack korrigieren
  241.     rts
  242.  
  243. * DisableVcc:
  244. * schaltet die Spannungsversorgung aus; siehe auch EnableVcc
  245. * bei GAL16V8: Pin22 vom Textool-Sockel
  246. * bei GAL20V8: Pin24 vom Textool-Sockel
  247. * Aufruf: DisableVcc();
  248. _DisableVcc:
  249.     movem.l    d0-d7/a0-a6,savereg    ; Register retten
  250.     move.l    #50000,-(sp)        ; sicherheitshalber 50mS warten, bis
  251.     jsr    _WaitForTimer        ; das GAL die letzte Aktion richtig
  252.     addq.l    #4,sp            ; verdaut hat
  253.     movem.l    savereg,d0-d7/a0-a6
  254.  
  255.     move.w    #IC1,-(sp)        ; IC1 selektieren
  256.     cmp.w    #GAL16V8,_GALType    ; 16V8 eingestellt?
  257.     bne.s    1$            ; nein, dann wird 20V8 angenommen!!!
  258.     move.w    #%11100111,d0        ; Q4,5 von IC1 auf LOW
  259.     bra.s    2$
  260. 1$    move.w    #%11101111,d0        ; Q5 auf HIGH
  261. 2$    and.w    d0,_outIC1
  262.     move.w    _outIC1,-(sp)
  263.     bsr    _WriteByte        ; IC1 setzen
  264.     addq.l    #4,sp            ; Stack korrigieren
  265.     rts
  266.  
  267.  
  268.  
  269. * EnableOutput:
  270. * OutputEnable-Eingang (OE) von IC3, IC4, IC5 auf HIGH
  271. * Aufruf: EnableOutput();
  272. _EnableOutput:
  273.     move.w    #IC1,-(sp)
  274.     or.w    #%00100000,_outIC1
  275.     move.w    _outIC1,-(sp)
  276.     bsr    _WriteByte
  277.     addq.l    #4,sp
  278.     rts
  279.  
  280. * DisableOutput:
  281. * OutputEnable-Eingang (OE) von IC3, IC4, IC5 auf LOW
  282. * Aufruf: DisableOutput();
  283. _DisableOutput:
  284.     move.w    #IC1,-(sp)
  285.     and.w    #%11011111,_outIC1
  286.     move.w    _outIC1,-(sp)
  287.     bsr    _WriteByte
  288.     addq.l    #4,sp
  289.     rts
  290.  
  291.  
  292.  
  293. * ReadByte:
  294. * lese ein Byte aus dem IC "ICx", wobei ICx=IC6 (nur ein Bit) oder IC7 ist
  295. * Aufruf: byte=ReadByte(IC);
  296. * PD3 ist bereits HIGH (muß es auch!, siehe _InitGAL und Beschreibung zu PD3)
  297. _ReadByte:
  298.     clr.w    d0
  299.     cmp.w    #IC6,4(sp)        ; IC6 angesprochen?
  300.     bne.s    IC7$            ; nein, dann IC7$
  301.     or.b    #%00000001,ciaaprb    ; PD0 auf HIGH=>HIGH am Clk vom IC7
  302.                     ; PD0 auf HIGH setzen=>IC6a selektiert
  303.  
  304.     movem.l    d0-d7/a0-a6,savereg    ; Register retten
  305.     move.l    #1,-(sp)        ; 1 us warten
  306.     jsr    _WaitForTimer        ; erlaubt ist
  307.     addq.l    #4,sp
  308.     movem.l    savereg,d0-d7/a0-a6
  309.  
  310.     move.b    ciabpra,d0
  311.     not.b    d0            ; invertieren
  312.     and.b    #%00000001,d0        ; BUSY-Bit ausmaskieren
  313.     bra.s    ready$            ; Pin22 (über IC6) ist ausgelesen
  314. IC7$
  315.  
  316.     and.b    #%11111110,ciaaprb    ; PD3 ist HIGH=>Lesen möglich
  317.     nop
  318.     or.b    #%00000100,ciaaprb    ; PD2 (Strobe) auf HIGH-> Daten werden
  319.     and.b    #%11111011,ciaaprb    ; vom Eingangsreg. in das Schiebereg.
  320.                     ; übernommen. Dann PD2 wieder auf LOW.
  321.                     ; PD3 ist auf HIGH=>Lesen ist möglich
  322.  
  323.     moveq    #7,d2            ; Schleifenzähler
  324. l$    rol.b    #1,d0
  325.     move.b    ciabpra,d1        ; BUSY-Bit holen
  326.     and.b    #%00000001,d1        ; BUSY-Bit ausmaskieren
  327.     or.b    d1,d0            ; BUSY-Bit in D0 eintragen
  328.     and.b    #%11111110,ciaaprb    ; PD0 auf LOW=>LOW am Clk-Eingang (IC7)
  329.     or.b    #%00000001,ciaaprb    ; PD0 auf HIGH=>HIGH am Clk-Eingang
  330.                     ; ==> nächstes Bit steht am Ausgang
  331.     nop
  332.     nop
  333.     and.b    #%11111110,ciaaprb    ; PD0 auf LOW=>IC6b ist selektiert (=>lesen möglich)
  334.     dbf    d2,l$            ; 8 Bits auslesen
  335.     not.b    d0            ; invertieren
  336. ready$    rts                ; D0=Rückgabewert (gelesenes Byte)
  337.  
  338.  
  339.  
  340. * WriteByte:
  341. * schreibt das Byte "byte" in das IC "IC", wobei IC=IC1, IC3, IC4 oder IC5
  342. * sein kann
  343. * zuerst wird das MSB übertragen!!!
  344. * Aufruf: WriteByte(byte,IC)
  345. _WriteByte:
  346.     movem.l    d0-d3,savereg        ; Register retten
  347.     move.w    4(sp),d0        ; Datenbyte nach D0
  348.     move.w    6(sp),d1        ; IC nach D1
  349.                 ; geschriebenes Byte mitprotokolieren
  350.     cmp.w    #IC1,d1
  351.     bne.s    1$
  352.     move.w    d0,_outIC1
  353.     bra.s    cont$
  354. 1$    cmp.w    #IC3,d1
  355.     bne.s    2$
  356.     move.w    d0,_outIC3
  357.     bra.s    cont$
  358. 2$    cmp.w    #IC4,d1
  359.     bne.s    3$
  360.     move.w    d0,_outIC4
  361.     bra.s    cont$
  362. 3$    move.w    d0,_outIC5
  363. cont$
  364.  
  365.     and.b    #%11111100,ciaaprb    ; PD0 und PD1 setzen (IC aus-
  366.     or.b    d1,ciaaprb        ; wählen)
  367.     and.b    #%11110111,ciaaprb    ; Adressdecoder aktivieren
  368.  
  369.     moveq    #7,d3            ; Schleifenzähler
  370.     ror.b    #3,d0            ; MSB nach D4 (Datenleitung)
  371. loop$    move.b    d0,d2            ; Datenbyte sichern
  372.     and.b    #%00010000,d2        ; Datenbit ausmaskieren
  373.     or.b    d2,ciaaprb        ; Datenbit (PD4) vom Par.-Port setzen
  374.  
  375.     or.b    #%00001000,ciaaprb    ; Clock-Impuls durch PD3 geben
  376.     and.b    #%11110111,ciaaprb    ; LOW-HIGH Übergang
  377.  
  378.     and.b    #%11101111,ciaaprb    ; Datenbit (PD4) auf LOW
  379.  
  380.     rol.b    #1,d0            ; nächstniedrigeres Bit senden
  381.     dbf    d3,loop$
  382.  
  383.     or.b    #%00001000,ciaaprb    ; Adressdecoder wieder deaktivieren!!!
  384.                     ; (sehr WICHTIG, siehe _InitGAL:)
  385.     or.b    #%00000100,ciaaprb    ; PD2 (Strobe) auf HIGH-> Daten werden
  386.     and.b    #%11111011,ciaaprb    ; vom Schieberegister in das Datenreg.
  387.                     ; übernommen. Dann PD2 wieder auf LOW.
  388.     movem.l    savereg,d0-d3
  389.     rts
  390.  
  391.  
  392. * SetRow:
  393. * Adresse an RAG0-RAG5 anlegen
  394. * Aufruf: SetRow(row);
  395. * row:      zu adressierende Zeile (0-63)
  396. _SetRow:
  397.  
  398.                     ; RAG5 setzen (Pin bei 16 und 20V8 gleich)
  399.     move.w    4(sp),d0        ; row holen
  400.     and.w    #$fe,_outIC5        ; Bit0(=RAG5) löschen
  401.     asr.b    #5,d0            ; Bit0 von D0=RAG5
  402.     or.w    d0,_outIC5        ; RAG5=Bit von D0=> RAG5 gesetzt
  403.  
  404.     cmp.w    #GAL16V8,_GALType    ; GAL16V8?
  405.     bne.s    GAL20V8$        ; nein, dann GAL20V8 annehmen
  406. GAL16V8$                ; RAG0 setzen
  407.     move.w    4(sp),d0        ; row holen
  408.     and.w    #$ef,_outIC3        ; Bit4(=RAG0) löschen
  409.     and.w    #1,d0            ; Bit0 von "row" ausmaskieren
  410.     asl.b    #4,d0
  411.     or.w    d0,_outIC3        ; Bit4(=RAG0) setzen
  412.                     ; RAG1-RAG4 setzen
  413.     move.w    4(sp),d0        ; row holen
  414.     and.w    #$0f,_outIC4        ; Bit4-7(=RAG1-RAG4) löschen
  415.     and.w    #%00011110,d0        ; Bit1-4 von "row" ausmaskieren
  416.     asl.w    #3,d0            ; an Bit4-7 schieben
  417.     or.w    d0,_outIC4        ; RAG1-RAG4 setzen
  418.     bra.s    write$
  419. GAL20V8$                ; RAG0 für GAL20V8 setzen
  420.      move.w    4(sp),d0        ; row holen
  421.     and.w    #%11011111,_outIC3    ; Bit5(=RAG0) löschen
  422.     and.w    #1,d0            ; Bit0 von "row" ausmaskieren
  423.     asl.b    #5,d0
  424.     or.w    d0,_outIC3        ; Bit5(=RAG0) setzen
  425.                     ; RAG4 setzen
  426.     move.w    4(sp),d0        ; row holen
  427.     and.w    #%01111111,_outIC4    ; Bit7(=RAG4) löschen
  428.     and.w    #%00010000,d0        ; Bit4 von "row" ausmaskieren
  429.     asl.w    #3,d0
  430.     or.w    d0,_outIC4        ; Bit7(=RAG4) setzen
  431.                     ; RAG1-RAG3 setzen
  432.     move.w    4(sp),d0        ; row holen
  433.     and.w    #%11100011,_outIC4    ; Bit2-4(=RAG1-RAG3) löschen
  434.     and.w    #%00001110,d0        ; Bit1-3 aus "row" ausmaskieren
  435.     asl.w    #1,d0
  436.     or.w    d0,_outIC4        ; RAG1-RAG3 setzen
  437.  
  438. write$                    ; errechnete Werte in ICs schreiben
  439.     move.w    #IC3,-(sp)
  440.     move.w    _outIC3,-(sp)
  441.     bsr    _WriteByte
  442.     addq.l    #4,sp
  443.     move.w    #IC4,-(sp)
  444.     move.w    _outIC4,-(sp)
  445.     bsr    _WriteByte
  446.     addq.l    #4,sp
  447.     move.w    #IC5,-(sp)
  448.     move.w    _outIC5,-(sp)
  449.     bsr    _WriteByte
  450.     addq.l    #4,sp
  451.  
  452. ;    movem.l    d0-d7/a0-a6,savereg    ; Register retten
  453. ;    move.l    #5,-(sp)        ; 5 us warten bevor nächste Aktion
  454. ;    jsr    _WaitForTimer        ; erlaubt ist
  455. ;    addq.l    #4,sp
  456. ;    movem.l    savereg,d0-d7/a0-a6
  457.  
  458.     rts
  459.  
  460.  
  461.  
  462. * SDIn:
  463. * lege ein Bit an den SDIn-Eingang (Pin 11 vom Textool-Sockel)
  464. * Aufruf: SDIn(bit);    bit: 0=LOW; 1=HIGH
  465. _SDIn:
  466.     move.w    4(sp),d0        ; Bit holen
  467.     asl.b    #2,d0            ; an die richtige Stelle schieben
  468.     and.w    #%11111011,_outIC5    ; SDIn-Bit löschen
  469.     or.w    d0,_outIC5        ; Bit auf LOW oder HIGH setzen
  470.     move.w    #IC5,-(sp)
  471.     move.w    _outIC5,-(sp)
  472.     bsr    _WriteByte
  473.     addq.l    #4,sp
  474.     rts
  475.  
  476.  
  477. * SDOut:
  478. * ein Bit aus dem SDOut-Ausgang lesen
  479. * Pin 14 (GAL16V8), Pin 15 (GAL20V8) am Textool-Sockel
  480. * Aufruf: bit=SDOut();
  481. * bit: 0: SDOut-Pin ist LOW; 1: SDOut-Pin ist HIGH
  482. _SDOut:
  483.     move.w    #IC7,-(sp)        ; ein Byte aus IC7 holen
  484.     bsr    _ReadByte        ; Bit0=Pin14, Bit1=Pin15
  485.     addq.l    #2,sp
  486.     cmp.w    #GAL16V8,_GALType    ; GAL16V8 eingestellt?
  487.     bne.s    1$            ; nein, dann GAL20V8
  488.     and.w    #1,d0            ; Bit0 ausmaskieren
  489.     bra.s    2$            ; D0=Bit
  490.                     ; GAL20V8
  491. 1$    asr.w    #1,d0            ; SDOut-Bit an Bit-Pos. 0
  492.     and.w    #1,d0
  493. 2$
  494.     rts
  495.  
  496.  
  497.  
  498.  
  499. * Clock:
  500. * erzeuge Clock-Impuls (Low-High-Low-Übergang) am SCLK-Eingang (Pin 10
  501. * vom Textool-Sockel
  502. * Aufruf: Clock();
  503. _Clock:
  504.     movem.l    d0-d7/a0-a6,savereg    ; Register retten
  505.  
  506.     or.w    #%00000010,_outIC5    ; SCLK-Bit auf HIGH
  507.     move.w    #IC5,-(sp)
  508.     move.w    _outIC5,-(sp)
  509.     bsr    _WriteByte
  510.     addq.w    #4,sp
  511.  
  512. ;    move.l    #5,-(sp)        ; 5 uS High-Impuls
  513. ;    jsr    _WaitForTimer
  514. ;    addq.l    #4,sp
  515.  
  516.     and.w    #%11111101,_outIC5    ; SCLK-Bit auf LOW
  517.     move.w    #IC5,-(sp)
  518.     move.w    _outIC5,-(sp)
  519.     bsr    _WriteByte
  520.     addq.w    #4,sp
  521.  
  522. ;    move.l    #5,-(sp)        ; 5 us warten bevor nächste Aktion
  523. ;    jsr    _WaitForTimer        ; erlaubt ist
  524. ;    addq.l    #4,sp
  525.     movem.l    savereg,d0-d7/a0-a6
  526.     rts
  527.  
  528.  
  529.  
  530. * STRImpuls:
  531. * setzt /STR-Eingang (Pin 13 am Textool-Socker) für die Dauer von "STRLength"
  532. * auf LOW
  533. * Aufruf: STRImpuls(long STRLength);
  534. * STRLength: Dauer des Low-Impulses in Mikrosekunden (Langwort!)
  535. _STRImpuls:
  536.     movem.l    d0-d7/a0-a6,savereg    ; Register retten
  537.  
  538.     move.l    4,a6
  539.     jsr    _LVOForbid(a6)
  540.  
  541.     and.w    #%11110111,_outIC5    ; STR-Pin auf LOW
  542.     move.w    #IC5,-(sp)
  543.     move.w    _outIC5,-(sp)
  544.     bsr    _WriteByte
  545.     addq.l    #4,sp
  546.  
  547.     cmp.l    #100,4(sp)        ; bis ein Wert in ein IC getaktet wird
  548.     bls.s    1$            ; vergehen ca. 100us => keinen Timer
  549.     move.l    4(sp),-(sp)        ; Dauer des Impulses in Mikrosekunden
  550.     jsr    _WaitForTimer        ; Low-Impuls
  551.     addq.l    #4,sp            ; Stack korrigieren
  552. 1$
  553.  
  554.     or.w    #%00001000,_outIC5    ; STR-Pin wieder auf HIGH
  555.     move.w    #IC5,-(sp)
  556.     move.w    _outIC5,-(sp)
  557.     bsr    _WriteByte
  558.     addq.l    #4,sp
  559.  
  560.     jsr    _LVOPermit(a6)
  561.  
  562. ;    move.l    #5,-(sp)        ; 5 us warten bevor nächste Aktion
  563. ;    jsr    _WaitForTimer        ; erlaubt ist
  564. ;    addq.l    #4,sp
  565.  
  566.     movem.l    savereg,d0-d7/a0-a6    ; Registerinhalte zurückholen
  567.     rts
  568.  
  569.  
  570. * SetPV:
  571. * Legt am P/V-Pin den entsprechenden Pegel für "Programmieren" bzw.
  572. * "Verify" an.
  573. * Aufruf:  SetPV(mode);
  574. * mode :   VERIFY (lesen, P/V low), PROG (schreiben, P/V high)
  575. _SetPV:
  576.     move.w    4(sp),d0        ; mode holen
  577.     cmp.w    #GAL16V8,_GALType    ; GAL16V8?
  578.     bne.s    1$            ; nein, dann 1$
  579.     move.w    #IC3,-(sp)        ; IC3 setzen
  580.     move.w    _outIC3,d1
  581.     and.w    #%11111011,d1
  582.     asl.b    #5,d0            ; Mode-Bit zu Bit 5 schieben
  583.     or.w    d0,d1
  584.     move.w    d1,-(sp)        ; P/V setzen
  585.     bsr    _WriteByte
  586.     addq.l    #4,sp
  587.     bra.s    2$
  588. 1$    
  589.     move.w    #IC3,-(sp)        ; IC3 setzen
  590.     move.w    _outIC3,d1
  591.     and.w    #%11111101,d1
  592.     asl.b    #6,d0            ; Mode-Bit zu Bit 6 schieben
  593.     or.w    d0,d1
  594.     move.w    d1,-(sp)        ; P,/V-Bit setzen
  595.     bsr    _WriteByte
  596.     addq.l    #4,sp
  597. 2$
  598. ;    movem.l    d0-d7/a0-a6,savereg    ; Register retten
  599. ;    move.l    #5,-(sp)        ; 5 us warten bevor nächste Aktion
  600. ;    jsr    _WaitForTimer        ; erlaubt ist
  601. ;    addq.l    #4,sp
  602. ;    movem.l    savereg,d0-d7/a0-a6
  603.  
  604.     rts
  605.  
  606.  
  607.  
  608.  
  609. * Edit-Mode:
  610. * schaltet das GAL in den Edit-Mode; /STR auf HIGH; P/V auf LOW
  611. * Aufruf: EditMode(mode);
  612. * mode: PROG oder VERIFY (für Spannungseinstellung)
  613. _EditMode:
  614.     movem.l    d0-d7/a0-a6,savereg    ; Register sichern
  615.  
  616.  
  617.                     ; GAL-Typ auswählen
  618.     cmp.w    #GAL16V8,_GALType   ; GAL16V8?
  619.     bne.s    1$            ; nein, dann 1$
  620.  
  621.     move.w    #IC3,-(sp)        ; IC3, P/V auf LOW
  622.     move.w    #%00000000,-(sp)
  623.     bsr    _WriteByte
  624.     addq.l    #4,sp
  625.  
  626.     move.w    #IC4,-(sp)
  627.     move.w    #%00000000,-(sp)    ; IC4 initialisieren
  628.     bsr    _WriteByte
  629.     addq.l    #4,sp
  630.  
  631.     move.w    #IC5,-(sp)        ; /STR auf HIGH
  632.     move.w    #%00011000,-(sp)    ; IC5 initialisieren
  633.     bsr    _WriteByte
  634.     addq.l    #4,sp
  635.     bra.s    2$
  636. 1$                    ; GAL20V8
  637.     move.w    #IC3,-(sp)        ; IC3, P/V auf LOW
  638.     move.w    #%00000000,-(sp)
  639.     bsr    _WriteByte
  640.     addq.l    #4,sp
  641.  
  642.     move.w    #IC4,-(sp)
  643.     move.w    #%00000000,-(sp)    ; IC4 initialisieren
  644.     bsr    _WriteByte
  645.     addq.l    #4,sp
  646.  
  647.     move.w    #IC5,-(sp)        ; /STR auf HIGH
  648.     move.w    #%00101000,-(sp)    ; IC5 initialisieren
  649.     bsr    _WriteByte
  650.     addq.l    #4,sp
  651. 2$
  652.  
  653.                     ; richtige Spannung auswählen
  654.     cmp.w    #VERIFY,4(sp)        ; Lesen?
  655.     bne.s    3$            ; nein, dann Programmieren!
  656.     move.w    #4,-(sp)        ; ja, dann 12.00 Volt einstellen
  657.     bsr    _SetVolt
  658.     addq.l    #2,sp
  659.     bra.s    4$
  660. 3$
  661.     move.w    _prog_volt,-(sp)    ; Programmierspannung einstellen
  662.     bsr    _SetVolt
  663.     addq.l    #2,sp
  664. 4$        
  665.  
  666.  
  667.     bsr    _VeditOn        ; Edit-Spannung aufbauen
  668.     move.l    #50000,-(sp)        ; 50 ms warten, bis sich die
  669.     jsr    _WaitForTimer        ; Edit-Spannung aufgebaut hat
  670.     addq.l    #4,sp
  671.     bsr    _EnableOutput        ; Bits anlegen
  672.     bsr    _EnableVcc        ; Vcc anlegen
  673.     move.l    #100000,-(sp)        ; Prellzeit der Relais überbrücken
  674.     jsr    _WaitForTimer
  675.     addq.l    #4,sp
  676.     bsr    _EnableVEdit        ; Edit-Spannung anlegen
  677.                     ; GAL befindet sich jetzt im Edit-Mode
  678.     move.l    #5,-(sp)        ; 5 us warten bevor nächste Aktion
  679.     jsr    _WaitForTimer        ; erlaubt ist
  680.     addq.l    #4,sp
  681.     movem.l    savereg,d0-d7/a0-a6    ; Registerinhalte zurückholen
  682.     rts
  683.  
  684.  
  685. * ExitEditMode:
  686. * Schaltet zuerst VEdit und VCC ab, dann wird der Inhalt der ICs
  687. * zurückgesetzt.
  688. * Aufruf: ExitEditMode();
  689. _ExitEditMode:
  690.     movem.l    d0-d7/a0-a6,savereg    ; Register sichern
  691.     bsr    _DisableVEdit
  692.     bsr    _DisableVcc
  693.     bsr    _InitGALer
  694.     bsr    _EnableOutput
  695.     movem.l    savereg,d0-d7/a0-a6
  696.     rts
  697.  
  698.  
  699.  
  700. * SetVolt:
  701. * selektiert durch IC 10 und IC11 die gewünschte Spannung
  702. * Aufruf: SetVolt(value);
  703. * value:  0=16.50 Volt; 1=15.75 Volt; 2=14.5 Volt; 3=14.00 Volt; 4=12.00 Volt
  704. *
  705. _SetVolt:
  706.  
  707.     move.w    4(sp),d0        ; Wert holen
  708.     move.w    d0,d1            ; Wert sichern
  709.  
  710.     move.w    #IC1,-(sp)
  711.     and.w    #%00000001,d1
  712.     rol.w    #7,d1
  713.     and.w    #%01111111,_outIC1
  714.     or.w    d1,_outIC1        ; Q8 (Pin 11) von IC1 setzen
  715.     move.w    _outIC1,-(sp)
  716.     bsr    _WriteByte
  717.     addq.l    #4,sp            ; Stack korrigieren
  718.  
  719.     move.w    #IC5,-(sp)
  720.     and.w    #%00000110,d0
  721.     rol.w    #5,d0
  722.     and.w    #%00111111,_outIC5
  723.     or.w    d0,_outIC5        ; Q7 und Q8 von IC5 setzen
  724.     move.w    _outIC5,-(sp)
  725.     bsr    _WriteByte
  726.     addq.l    #4,sp            ; Stack korrigieren
  727.  
  728.     rts
  729.  
  730.  
  731.  
  732.  
  733.     dseg
  734.  
  735. ; Zwischenspeicher, um Register zu retten ohne den Stack zu benützen
  736. savereg:    ds.l    15        ; 8 Datenregister, 7 Adressregister
  737.  
  738. _outIC1:    dc.w    0
  739. _outIC3:    dc.w    0
  740. _outIC4:    dc.w    0
  741. _outIC5:    dc.w    0
  742. _GALType:    dc.w    0
  743.  
  744. cia_addrb:    dc.b    0
  745. cia_bddra:    dc.b    0
  746.  
  747.     END
  748.